
import { window, Disposable, workspace, TextDocumentChangeEvent, TextDocument, Position } from "vscode";
import { Lazy } from "../../../utils/lazy";
import TypeScriptServiceClientHost from "../../../typeScriptServiceClientHost";
export let 未译词典!: Map<string, string>;
export let 汉英多译!: Map<string, string>;
export let 英汉多译!: Map<string, string[]>;
export let 通用词典!: Map<string, string>;
export let 增加的词典!: Map<string, string>;
export let 反向词典: Map<string, string> = new Map();

const 正则 = /^\s*"(.+)?"\s*:/;

export class 外部词典编辑命令_ {
    public static readonly ID = 'ctsscript.外部词典编辑命令_';
    public readonly ID = 外部词典编辑命令_.ID;
    public 清理!: Disposable;
    constructor(
        private readonly lazyClientHost: Lazy<TypeScriptServiceClientHost>,
    ) { }
    public async execute() {
        if (!window.activeTextEditor || !window.activeTextEditor.document) {
            return;
        }
        const 当前文档 = window.activeTextEditor!.document;
        const 规范化路径 = this.lazyClientHost.value.serviceClient.normalizedPath(当前文档.uri);
        if (规范化路径 && 规范化路径.endsWith("dictconfig.json")) {
            填充初始化映射(JSON.parse(当前文档.getText()) as 词典文件_);
            通用词典.forEach((v, k) => {
                反向词典.set(v, k);
            });
            let 处理垃圾: Disposable[] = [];
            workspace.onDidChangeTextDocument(this.监听输入, this, 处理垃圾);
            this.清理 = Disposable.from(...处理垃圾);
        }
    }

    dispose() {
        this.清理.dispose();
    }

    public 监听输入(事件: TextDocumentChangeEvent) {
        if (事件.contentChanges[0].range) {
            this.处理事件(事件.document, 事件.contentChanges[0].range.start)
        }
    }
    public 处理事件(文档: TextDocument, 位置: Position) {
        let 当前词 = 文档.getText(文档.getWordRangeAtPosition(位置));
        当前词 = 当前词.slice(1, -1);
        const 行文本 = 文档.lineAt(位置.line).text;
        let 词键!: string;
        const 匹配 = 正则.exec(行文本); if (匹配) {
            词键 = 匹配[1];
        }
        if (当前词 && 反向词典.has(当前词) && 词键) {
            window.showInformationMessage(`词典: <${词键}:${当前词}> 与词典: <${反向词典.get(当前词)}:${当前词}> 译文重复`, { title: "中文值重复", isCloseAffordance: true });
        }
        else if (当前词 && 词键) {
            (增加的词典 || (增加的词典 = new Map)).set(词键, 当前词);
            反向词典.set(当前词, 词键);
        }
    }
}

function 填充初始化映射(结构化文档: 词典文件_) {
    if (结构化文档) {
        if (结构化文档.未译词典) {
            for (let k in 结构化文档.未译词典) {
                if (有属性(结构化文档.未译词典, k)) {
                    (未译词典 || (未译词典 = new Map<string, string>())).set(k, 结构化文档.未译词典[k]);
                }
            }
        }
        if (结构化文档.汉英多译) {
            for (let k in 结构化文档.汉英多译) {
                if (有属性(结构化文档.汉英多译, k)) {
                    (汉英多译 || (汉英多译 = new Map<string, string>())).set(k, 结构化文档.汉英多译[k]);
                }
            }
        }
        if (结构化文档.英汉多译) {
            for (let k in 结构化文档.英汉多译) {
                if (有属性(结构化文档.英汉多译, k)) {
                    (英汉多译 || (英汉多译 = new Map<string, string[]>())).set(k, 结构化文档.英汉多译![k]);
                }
            }
        }
        if (结构化文档.通用词典) {
            for (let k in 结构化文档.通用词典) {
                if (有属性(结构化文档.通用词典, k)) {
                    (通用词典 || (通用词典 = new Map<string, string>())).set(k, 结构化文档!.通用词典![k]);
                }
            }
        }
    }
    return;
}

function 有属性<T>(本体对象: T, k: string): boolean {
    return Object.prototype.hasOwnProperty.call(本体对象, k)
}

type 词典文件_ = {
    通用词典?: 原始通用词典对象_;
    未译词典?: 原始通用词典对象_;
    英汉多译?: 原始多译词典对象_;
    汉英多译?: 原始通用词典对象_;
}


type 原始通用词典对象_ = {
    [index: string]: string;
}

type 原始多译词典对象_ = {
    [index: string]: string[];
}
